home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / zapem-0.000 / zapem-0 / zapem / sprite.cc < prev    next >
C/C++ Source or Header  |  1995-06-03  |  7KB  |  383 lines
  1. /*    Copyright Alex Hornby 1994/1995. All rights reserved.
  2.      See file README for details
  3. */
  4.  
  5. /* C++ code for sprite block copy wrapper */
  6.  
  7. #include <SLList.h>
  8. #include <assert.h>
  9. #include <vga.h>
  10. #include <iostream.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13.  
  14. #include "btypes.h"
  15. #include "palette.h"
  16. #include "sprite.h"
  17. #include "asmblock.h"
  18. #include "gif.h"
  19. #include "alopen.h"
  20.  
  21. extern Palette gamepal;
  22.  
  23. /* Static data members */
  24. SLList<Sprite*> Sprite :: vlist;
  25. SLList<Sprite*> Sprite :: appearlist;
  26. SLList<Sprite*> Sprite :: disappearlist;
  27.  
  28. /***************************************************************************
  29.             LET THE FUNCTIONS BEGIN!
  30. ****************************************************************************/
  31.  
  32. Sprite::~Sprite() 
  33. {
  34.     if( backmem!=0) delete backmem;
  35.     if (visibleflag==true) setVisible(false);
  36. }
  37.  
  38. Sprite::Sprite() : Animation(), Screen() 
  39. {
  40.     visibleflag=false;
  41.     backmem=0;
  42. }
  43.  
  44. void
  45. Sprite::copy( const Sprite& s)
  46. {
  47.     xp=s.xp;
  48.     yp=s.yp;
  49.     oldxp=s.oldxp;
  50.     oldyp=s.oldyp;
  51.     deltax=s.deltax;
  52.     deltay=s.deltay;
  53.     setVisible(s.getVisible());
  54.  
  55.     if(backmem!=0) 
  56.         delete [] backmem;
  57.     backmem=new byte [ByteLength];
  58.     if(s.backmem!=0)
  59.         memcpy(backmem, s.backmem, ByteLength);
  60. } 
  61.  
  62. Sprite::Sprite( const Sprite& s) : Animation(s), Screen(s)
  63. {
  64.     copy(s);
  65. }
  66.  
  67. Sprite&
  68. Sprite::operator=( const Sprite& s) 
  69. {
  70.     if( &s != this)
  71.     {
  72.         Animation::operator=(s);
  73.         Screen::operator=(s);
  74.         copy(s);
  75.     }
  76.     return *this;
  77. }
  78.  
  79. /* Load the single sprite gif file int sprite bank slot */ 
  80. /* Yuck! */
  81. void
  82. Sprite :: gifLoadAndCut(char *filename, int slot)
  83. {
  84.     FILE *fp=alopen(filename, "rb");
  85.     Gif gif;
  86.     Palette gifpal;
  87.     gif.Load(fp);
  88.     
  89.     gifpal.scan(gif.getPtr(), gif.getWidth()*gif.getHeight());
  90.         gif.SetPalette(gifpal);
  91.         gamepal.remap(gif.getPtr(), gif.getWidth()*gif.getHeight() , gifpal);
  92.  
  93.     // Save the old screen settings
  94.     pixel *oldgmem=getGraphMem();
  95.     int oldswidth=getScreenWidth();
  96.     int oldsheight=getScreenHeight();
  97.     // Set the screen up to the same size as the picture
  98.     setGraphMem(gif.getPtr());
  99.     setScreenWidth(gif.getWidth());
  100.     setScreenHeight(gif.getHeight());
  101.  
  102.     // Cut the sprite
  103.     Cut(0, 0, gif.getWidth(), gif.getHeight(), slot);
  104.     // Restore the screen settings
  105.     setGraphMem(oldgmem);
  106.     setScreenHeight(oldsheight);    
  107.     setScreenWidth(oldswidth);
  108. }
  109.  
  110. /* Have we collided with something? */
  111. bool
  112. Sprite :: collide(const Sprite& s)
  113. {
  114.     int xd=s.getXp()-getXp();
  115.     int yd=s.getYp()-getYp();
  116.  
  117.     if( (xd< getWidth() && xd > -s.getWidth() ) && 
  118.         (yd< getHeight() && yd > -s.getHeight()) )
  119.         return true;
  120.     else
  121.         return false;     
  122. }
  123.  
  124. void
  125. Sprite :: setSlot(int slot)
  126. {
  127.         assert(slot<MAXFRAME);
  128.         assert(slot>=0);
  129.         curslot=slot;
  130.         blockmem=sprbank[slot].block;
  131.         maskmem=sprbank[slot].mask;
  132.         width=sprbank[slot].width;
  133.         height=sprbank[slot].height;
  134.         ByteLength=sprbank[slot].ByteLength;
  135. }
  136.  
  137. void 
  138. Sprite :: appear(void)
  139. {
  140.     Sprite *x=this;
  141.     appearlist.append(x);
  142. }
  143.  
  144. void 
  145. Sprite :: disappear(void)
  146. {
  147.     Sprite *x=this;
  148.     disappearlist.append(x);
  149. }
  150.  
  151. void
  152. Sprite :: setVisible( bool v)
  153. {
  154.     if( v==true)    
  155.     {
  156.         if(visibleflag==false)
  157.         {
  158.             visibleflag=true;        
  159.             vlist.append(this);
  160.         }
  161.     }
  162.     else
  163.     {
  164.         Pix here, prev=0;
  165.  
  166.         if(visibleflag==true)
  167.         {
  168.             for(here=vlist.first(); here!=0; vlist.next(here))
  169.             {
  170.                 if(vlist(here)==this)
  171.                 {
  172.                     if(here==vlist.first())
  173.                         vlist.del_front();
  174.                     else
  175.                         vlist.del_after(prev);
  176.                     here=0;
  177.                 }    
  178.                 prev=here;                
  179.             }
  180.         }
  181.     visibleflag=false;
  182.     }
  183. }
  184.  
  185. void 
  186. Sprite :: Cut ( uint32 x1, uint32 y1, uint32 xw, uint32 yw, int slot)
  187. {
  188.     curslot=slot;
  189.     /* Make the slot equal our new graphic. There should really be 
  190.        some checking to see if the slot is already in use */
  191.     sprbank[slot].width=width=xw;
  192.     sprbank[slot].height=height=yw;
  193.     sprbank[slot].ByteLength=ByteLength=xw*yw;
  194.     xp=x1;yp=y1;
  195.  
  196.     /* if memory in use then free it. This is extremely dodgy! */
  197.     if( backmem!=0 ) delete backmem; 
  198.  
  199.     /* reserve block memory */
  200.     blockmem=new byte [ByteLength];
  201.     maskmem=new byte [ByteLength];
  202.     backmem=new byte [ByteLength];
  203.     sprbank[slot].block=blockmem;
  204.     sprbank[slot].mask=maskmem;
  205.  
  206.     /* call assembly routines */
  207.     cutblocknew( getGraphMem()+x1+(y1*getScreenWidth()), blockmem, getScreenWidth(), width, height);
  208.     cutblocknew( getGraphMem()+x1+(y1*getScreenWidth()), backmem, getScreenWidth(), width, height);
  209.     MakeMask();
  210. }
  211.  
  212. void
  213. Sprite :: MakeMask(byte maskcolour)
  214. {
  215.     uint32 count;
  216.     byte *maskptr, *blockptr;
  217.  
  218.     maskptr=maskmem;
  219.     blockptr=blockmem;
  220.     for( count=0; count<ByteLength; count++)
  221.     {
  222.         if(*blockptr==maskcolour)
  223.             *maskptr=255;
  224.         else
  225.             *maskptr=0;
  226.         maskptr++;
  227.         blockptr++;
  228.     }
  229. }
  230.  
  231. void
  232. Sprite :: Recut( uint32 x1, uint32 y1)
  233. {
  234.     /* call assembly routine */
  235.     cutblock( getGraphMem()+x1+(y1*getScreenWidth()), blockmem, width, height); 
  236.     MakeMask();
  237. }
  238.  
  239. void
  240. Sprite :: Paste( uint32 x1, uint32 y1)
  241. {
  242.     /* Straight into the assembly bit */
  243.     pasteblock( blockmem, getGraphMem()+x1+(y1*getScreenWidth()), width, height );
  244. }
  245.  
  246. void
  247. Sprite :: getBack( uint32 x1, uint32 y1)
  248. {
  249.     xp=oldxp=x1;yp=oldyp=y1;
  250.  
  251.     /* get new background */
  252.     if(backmem==0) backmem=new byte[ByteLength];
  253.     cutblock( getGraphMem()+xp+(yp*getScreenWidth()),backmem, width, height );
  254. }
  255.  
  256. void
  257. Sprite :: ReplaceAll(void)
  258. {
  259.     Pix cur, n;    // n is needed because of animation can cause NULL pix
  260.  
  261.     cur=vlist.first();
  262.     assert(cur!=0);
  263.  
  264.     while( cur!=0 )
  265.     {
  266.         vlist(cur)->fixBack();
  267.         n=cur;
  268.         vlist.next(n);
  269.         if( vlist(cur)->getAnim()==true)
  270.             vlist(cur)->doAnim();
  271.         cur=n;
  272.     }
  273.  
  274.     cur=disappearlist.first();
  275.     while(cur!=0)
  276.     {
  277.         disappearlist(cur)->setVisible(false);
  278.         disappearlist.next(cur);
  279.     }
  280.  
  281.     while(!disappearlist.empty())
  282.     {
  283.         disappearlist.remove_front();
  284.     }
  285. }
  286.  
  287. void
  288. Sprite :: PasteAll(void)
  289. {
  290.     Pix cur=vlist.first();
  291.     while( cur!=0 )
  292.     {
  293.         vlist(cur)->Transpaste();
  294.         vlist.next(cur);
  295.     }
  296. }
  297.  
  298. void
  299. Sprite :: UpdateAll(void)
  300. {
  301.     ReplaceAll();
  302.     PasteAll();    
  303. }
  304.  
  305. void
  306. Sprite :: hideAll(void)
  307. {
  308.     Pix cur, n;    // n is needed because of animation can cause NULL pix
  309.  
  310.     cur=vlist.first();
  311.  
  312.     while( cur!=0 )
  313.     {
  314.         n=cur;
  315.         vlist.next(n);
  316.         vlist(cur)->setVisible(false);
  317.         cur=n;
  318.     }
  319. }
  320.  
  321. void
  322. Sprite :: Update( int x1, int y1)
  323. {
  324.     xp=x1;yp=y1;
  325.  
  326.     // replace old bit
  327.     pasteblock( backmem, getGraphMem()+oldxp+(oldyp*getScreenWidth()), width, height );
  328.  
  329.     // get new background
  330.     cutblock( getGraphMem()+xp+(yp*getScreenWidth()),backmem, width, height );
  331.  
  332.     // display sprite
  333.     Transpaste();
  334. }
  335.  
  336. void
  337. Sprite :: Transpaste( void)
  338. {
  339.     /*
  340.     andpasteblock( maskmem, getGraphMem()+xp+(yp*getScreenWidth()), width, height );
  341.     xorpasteblock( blockmem, getGraphMem()+xp+(yp*getScreenWidth()), width, height );
  342.     */
  343.     transpasteblock( blockmem, maskmem, getGraphMem()+xp+(yp*getScreenWidth()), width, height );
  344.     oldxp=xp;oldyp=yp;
  345. }
  346.  
  347. void 
  348. Sprite::getAll()
  349. {
  350.     Pix cur=appearlist.first();
  351.     while(cur!=0)
  352.     {
  353.         appearlist(cur)->setVisible(true);
  354.         appearlist(cur)->getBack();
  355.         appearlist.next(cur);
  356.     }
  357.     while(!appearlist.empty())
  358.     {
  359.         appearlist.remove_front();
  360.     }
  361.     
  362.     cur=vlist.first();
  363.     while( cur!=0 )
  364.     {
  365.         vlist(cur)->CutBack();
  366.         vlist.next(cur);
  367.     }
  368. }
  369.  
  370. void
  371. Sprite :: fixBack( void )
  372. {
  373.     // replace old bit
  374.     pasteblock( backmem, getGraphMem()+oldxp+(oldyp*getScreenWidth()), width, height );
  375. }
  376.  
  377. void 
  378. Sprite :: CutBack( void)
  379. {
  380.     // get new background
  381.     cutblock( getGraphMem()+xp+(yp*getScreenWidth()),backmem, width, height );
  382. }
  383.